Micron Document
██████╗ ███████╗████████╗██╗██████╗ ███████╗██████╗ ██╗ █████╗
██╔══██╗██╔════╝╚══██╔══╝██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗
██████╔╝█████╗ ██║ ██║██████╔╝█████╗ ██║ ██║██║███████║
██╔══██╗██╔══╝ ██║ ██║██╔═══╝ ██╔══╝ ██║ ██║██║██╔══██║
██║ ██║███████╗ ██║ ██║██║ ███████╗██████╔╝██║██║ ██║
╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚══════╝╚═════╝ ╚═╝╚═╝ ╚═╝


🬧 The NomadNet Encyclopedia | Archives | Info
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b

🔍 Search

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Secure Hash Algorithm
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
top
Con il termine mwawSHA (mwbaacronimo dell'mwbqinglese mwbgSecure Hash Algorithm) si indica una famiglia di cinque diverse mwbwfunzioni crittografiche di hash sviluppate a partire dal mwcq1993 dalla mwcgmwcwNational Security Agency (NSA) e pubblicato dal mwdaNIST come mwdqstandard federale dal governo degli mwdgUSA (mwdwFIPS PUB 180-4).

Come ogni mweqalgoritmo di mweghash, l'SHA produce un mwewmessage digest, o "impronta del mwfamessaggio", di lunghezza fissa partendo da un messaggio di lunghezza variabile. La sicurezza di un mwfqalgoritmo di mwfghash risiede nel fatto che la funzione non sia invertibile (non sia cioè possibile risalire al messaggio originale conoscendo solo questo dato) e che non deve essere mai possibile creare mwfwintenzionalmente due messaggi diversi con lo stesso mwgadigest. Gli algoritmi della famiglia sono denominati mwgqSHA-1, mwggSHA-224, mwgwSHA-256, mwhaSHA-384 e mwhqSHA-512: le ultime 4 varianti sono spesso indicate genericamente come mwhgSHA-2, per distinguerle dal primo. Il primo produce un mwhwdigest del messaggio di soli 160 mwiabit, mentre gli altri producono mwiqdigest di lunghezza in bit pari al numero indicato nella loro sigla (SHA-256 produce un mwigdigest di 256 bit). L'SHA-1 è il più diffuso algoritmo della famiglia SHA ed è utilizzato in numerose applicazioni e protocolli nonostante sia ormai insicuro e verrà presto sostituito dagli altri, più moderni ed efficienti.

La sicurezza di SHA-1 è stata appunto compromessa dai mwjacrittoanalisti.cite-ref-1[1] Sebbene non siano ancora noti attacchi alle varianti SHA-2, esse hanno un algoritmo simile a quello di SHA-1 per cui sono in atto sforzi per sviluppare algoritmi di mwkqhashing alternativi e migliorati.cite-ref-2[2]cite-ref-3[3] Un concorso aperto per la realizzazione di una nuova funzione mwmgSHA-3 venne annunciato nel mwmwFederal Register il 2 novembre 2007cite-ref-autogenerato1-4-0[4] dal NIST e attraverso una mwoacompetizione pubblica, simile a quella adottata per il processo di sviluppo dell'mwoqAES,cite-ref-5[5] ha portato in data 2 ottobre 2012 ad annunciare come vincitore l'algoritmo Keccak. Opera di un team di analisti italiani e belgi, il Keccakcite-ref-6[6] sembra dunque destinato a venire gradualmente incluso e adottato nelle soluzioni di mwqwsicurezza informatica più variegate.

Il 23 febbraio 2017 un team di Google ha annunciato la prima tecnica pratica per generare una mwrqcollisione hash.cite-ref-7[7]cite-ref-8[8]

Contents

SHA-3
Note

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

SHA-0 e SHA-1

La specifica originale dell'algoritmo fu pubblicata nel 1993 come mwyqSecure Hash Standard, mwygFIPS PUB 180, dal mwywNIST. Ci si riferisce spesso a questa versione come mwzaSHA-0 per distinguerla dalle successive versioni. Fu ritirata dall'mwzqNSA breve tempo dopo la pubblicazione e fu soppiantata da una versione rivista, pubblicata nel 1995 (FIPS PUB 180-1) e solitamente nota come mwzgSHA-1. L'SHA-1 differisce dall'SHA-0 unicamente per una sola rotazione di bit nel processo di preparazione del messaggio della sua funzione di compressione ad una via; ciò fu fatto, secondo l'NSA, per correggere un difetto nell'algoritmo originale, il quale riduceva la sicurezza crittografica di SHA-0. Ad ogni modo, l'NSA non fornì nessuna ulteriore spiegazione chiarificante. Sono state in seguito riportate debolezze sia nel codice dell'SHA-0 sia in quello dell'SHA-1. L'SHA-1 pare offrire maggiore resistenza agli attacchi, a supporto dell'asserzione dell'NSA che il cambiamento aumentò la sicurezza.

L'SHA-1 (così come l'SHA-0) produce un mwaadigest di 160 bit da un messaggio con una lunghezza massima di 2mwaq64-1 bit, essendo fondato sullo schema di Merkel-Damgard si basa su principi simili a quelli usati da mwagRonald L. Rivest del mwawMIT nel mwbadesign degli algoritmi mwbqMD4 e mwbgMD5.

Funzionamento

mwcqPasso 1 (Imbottitura): Al messaggio originale vengono aggiunti dei bit di "imbottitura" affinché la lunghezza finale del messaggio risulti congruente a 448 modulo 512, così facendo la lunghezza in bit di "messaggio+imbottitura" divisa per 512 darà resto 448.

mwcwPasso 2 (Aggiunta lunghezza): Alla sequenza di bit (messaggio+imbottitura) creata durante il passo 1 viene aggiunto un intero unsigned di 64bit contenente la lunghezza del messaggio originale. Alla fine di questi due primi passi otteniamo una sequenza di bit che è un multiplo di 512.

mwdqPasso 3 (Inizializzazione del buffer MD): Un buffer di 160bit suddiviso in 5 registri da 32bit ciascuno viene creato per la memorizzazione di alcuni passaggi intermedi. I 5 registri verranno convenzionalmente indicati con (A,B,C,D,E) ed inizializzati con i seguenti valori esadecimali:

1. A = 67452301
2. B = EFCDAB89
3. C = 98BADCFE
4. D = 10325476
5. E = C3D2E1F0

mwfqPasso 4 (Elaborazione dei blocchi da 512bit): La sequenza di bit "messaggio+imbottitura+lunghezzaMessaggio" viene divisa in blocchi da 512bit, che identificheremo con Bmwfgn con n che va da 0 a L. Il fulcro dell'algoritmo SHA-1 è chiamato mwfwcompression function ed è formato da 4 cicli di 20 passi cadauno. I cicli hanno una struttura molto simile tra di loro se non per il fatto che utilizzano una differente funzione logica primitiva. Ogni blocco viene preso come parametro di input da tutti e 4 i cicli insieme ad una costante K e i valori dei 5 registri. Alla fine della computazione otterremo dei nuovi valori per A,B,C,D,E che useremo per la computazione del blocco successivo sino ad arrivare al blocco finale F.

L'insieme SHA-2

Nel mwhg2001 il NIST pubblicò quattro funzioni di mwhwhash addizionali facenti parte della famiglia SHA, ognuna con un mwiadigest più lungo di quello originale, collettivamente denominate mwiqSHA-2 (anche se questo termine non è mai stato ufficialmente standardizzato). Queste varianti sono note, come detto, con la lunghezza in bit del mwigdigest generato a seguire la sigla ufficiale dellmwiw'mwjahash: mwjqSHA-224, mwjgSHA-256, mwjwSHA-384 e mwkaSHA-512, con, rispettivamente, mwkqhash di 224, 256, 384 e 512 bit. Da notare che gli ultimi tre algoritmi furono ufficializzati come standard nel mwkg2002 mentre l'SHA-224 fu introdotto nel febbraio del mwkw2004: quest'ultimo presenta un mwlahash di lunghezza identica a quella di 2 chiavi del mwlqTriple DES.

Tutte queste varianti sono brevettate dal governo statunitense, ma pubblicate con licenza libera.cite-ref-9[9].

Gli algoritmi SHA-256 e SHA-512 lavorano, rispettivamente, con mwnaword di 32 e 64 bit: utilizzano un numero differente di rotazioni e di costanti addizionali, ma la loro struttura è sostanzialmente identica. Gli algoritmi SHA-224 e SHA-384 sono semplicemente versioni troncate dei precedenti due, con mwnqhash calcolati con differenti valori iniziali.

Gli algoritmi SHA-2 non hanno ricevuto, a differenza dell'SHA-1, molta attenzione dalla comunità dei crittoanalisti per cui la loro sicurezza in campo crittografico non è stata del tutto provata. Gilbert e Handschuh (mwnw2003) hanno studiato queste nuove varianti e non hanno trovato vulnerabilitàcite-ref-10[10].

SHA-3

La mwpwcompetizione che ha portato al rilascio del nuovo standard mwqaSHA-3 è stata ufficialmente lanciata il 2 novembre mwqq2007cite-ref-autogenerato1-4-1[4]. Il 2 ottobre 2012 la mwrgNIST ha proclamato come vincitore l'algoritmo di Keccak mwsaSHA-3.

Comparazione delle funzioni SHA

Nella tabella sottostante sono riportate le caratteristiche principali degli algoritmi della famiglia SHA (Per mwswStato interno si intende la somma interna dopo ogni compressione di un blocco di dati).

| Algoritmo e variante | Algoritmo e variante | Dimensione dell'output (bit) | Dimensione dello stato interno (bit) | Dimensione del blocco (bit) | Max. dimensione del messaggio (bit) | Dimensione della word (bit) | Passaggi | Operazioni | Collisioni trovate |
|---|---|---|---|---|---|---|---|---|---|
| SHA-0 | SHA-0 | 160 | 160 | 512 | 2 64 − 1 | 32 | 80 | +,and,or,xor, rotl | Sì |
| SHA-1 | SHA-1 | 160 | 160 | 512 | 2 64 − 1 | 32 | 80 | +,and,or,xor, rotl | Attacco 2 53 [ 11 ] |
| SHA-2 | SHA-256/224 | 256/224 | 256 | 512 | 2 64 − 1 | 32 | 64 | +,and,or,xor,shr, rotr | Nessuna |
| SHA-2 | SHA-512/384 | 512/384 | 512 | 1024 | 2 128 − 1 | 64 | 80 | +,and,or,xor,shr, rotr | Nessuna |

Applicazioni

SHA-1 è l'algoritmo più utilizzato della famiglia SHA. Costituisce la base di numerose applicazioni e protocolli, inclusi il mw-wTLS ed SSL, il mw-aPGP, l'mw-qSSH, l'mw-gS/MIME e l'mw-wIPsec. L'SHA-1 è anche utilizzato in sistemi di mwaqacontrollo versione, come il mwaqeGit, per identificare la revisione dei software e come somma di controllo per verificare l'integrità di file di grosse dimensioni in cataloghi online.

Gli algoritmi SHA sono anche utilizzati negli algoritmi per la mwaqmfirma digitale dei documenti, quali ad esempio l'mwaqqHMAC, e sono stati presi come base per i mwaqucifrari a blocchi SHACAL.

Esempi e pseudocodice

Hash di esempio

Questo è un esempio di mwaqodigest generato dall'SHA-1 (tutti i messaggi sono codificati in mwaqsASCII):

SHA1("Cantami o diva del pelide Achille l'ira funesta")
= 1f8a690b7366a2323e2d5b045120da7e93896f47

Anche una minima variazione nel messaggio genera, ineluttabilmente, un mwaq4hash completamente differente a causa di una mwaq8reazione a catena nota come mwaraeffetto valanga. Ad esempio, sostituendo mwareCantami con mwariContami otteniamo:

SHA1("Contami o diva del pelide Achille l'ira funesta")
= e5f08d98bf18385e2f26b904cad23c734d530ffb

Il mwarydigest corrispondente alla stringa vuota è:

SHA1("")
= da39a3ee5e6b4b0d3255bfef95601890afd80709

Pseudocodice di SHA-1

mwaroPseudocodice dell'algoritmo SHA-1:

Note: All variables are unsigned 32 bits and wrap modulo 232 when calculating

Initialize variables:
h0 = 0x67452301
h1 = 0xEFCDAB89
h2 = 0x98BADCFE
h3 = 0x10325476
h4 = 0xC3D2E1F0

Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number ≥ 0 such that the resulting message
length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
break chunk into sixteen 32-bit big-endian words w[i], 0 <= i <= 15

Extend the sixteen 32-bit words into eighty 32-bit words:
for i from 16 to 79
w[i] = (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1

Initialize hash value for this chunk:
a = h0
b = h1
c = h2
d = h3
e = h4

Main loop:
for i from 0 to 79
if 0 ≤ i ≤ 19 then
f = (b and c) or ((not b) and d)
k = 0x5A827999
else if 20 ≤ i ≤ 39
f = b xor c xor d
k = 0x6ED9EBA1
else if 40 ≤ i ≤ 59
f = (b and c) or (b and d) or (c and d)
k = 0x8F1BBCDC
else if 60 ≤ i ≤ 79
f = b xor c xor d
k = 0xCA62C1D6

temp = (a leftrotate 5) + f + e + k + w[i]
e = d
d = c
c = b leftrotate 30
b = a
a = temp

Add this chunk's hash to result so far:
h0 = h0 + a
h1 = h1 + b
h2 = h2 + c
h3 = h3 + d
h4 = h4 + e

Produce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4

Le seguenti formule possono essere utilizzate per calcolare mwawif nel ciclo principale qui sopra pubblicato al posto di quelle originali pubblicate nel documento ufficiale FIPS PUB 180-1:

(0 ≤ i ≤ 19): f = d xor (b and (c xor d)) (alternative 1)
(0 ≤ i ≤ 19): f = (b and c) xor ((not b) and d) (alternative 2)
(0 ≤ i ≤ 19): f = (b and c) + ((not b) and d) (alternative 3)
(40 ≤ i ≤ 59): f = (b and c) or (d and (b or c)) (alternative 1)
(40 ≤ i ≤ 59): f = (b and c) or (d and (b xor c)) (alternative 2)
(40 ≤ i ≤ 59): f = (b and c) + (d and (b xor c)) (alternative 3)
(40 ≤ i ≤ 59): f = (b and c) xor (b and d) xor (c and d) (alternative 4)

Pseudocodice di SHA-256 (una variante di SHA-2)

Pseudocode dell'algoritmo SHA-256. Notare l'incremento nel mescolamento dei bit delle word mway8wmwaza[16..63mwaze] rispetto all'SHA-1.

Note: All variables are unsigned 32 bits and wrap modulo 232 when calculating

Initialize variables
(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
h0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19

Initialize table of round constants
(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
k[0..63] :=
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number >= 0 such that the resulting message
length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
break chunk into sixteen 32-bit big-endian words w[0..15]

Extend the sixteen 32-bit words into sixty-four 32-bit words:
for i from 16 to 63
s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3)
s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor (w[i-2] rightshift 10)
w[i] := w[i-16] + s0 + w[i-7] + s1

Initialize hash value for this chunk:
a := h0
b := h1
c := h2
d := h3
e := h4
f := h5
g := h6
h := h7

Main loop:
for i from 0 to 63
s0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
maj := (a and b) xor (a and c) xor (b and c)
t2 := s0 + maj
s1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
ch := (e and f) xor ((not e) and g)
t1 := h + s1 + ch + k[i] + w[i]

h := g
g := f
f := e
e := d + t1
d := c
c := b
b := a
a := t1 + t2

Add this chunk's hash to result so far:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e
h5 := h5 + f
h6 := h6 + g
h7 := h7 + h

Produce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7

Le funzioni mwagach e mwagemaj possono essere ottimizzate nel modo descritto per quelle dell'SHA-1.

L'SHA-224 è identico all'SHA-256 tranne che:

• i valori iniziali delle variabili mwaguh0-mwagyh7 sono differenti e
• l'output è costruito omettendo mwaggh7.

L'SHA-512 è identico nella struttura ma:

• tutti i numeri sono lunghi 64 bit,
• sono eseguiti 80 passaggi invece di 64,
• i valori iniziali e le costanti da addizionare sono estesi a 64 bit e
• le quantità delle rotazioni (mwag8rotate) e degli spostamenti (mwahashift) sono differenti.

L'SHA-384 è identico all'SHA-512 tranne che:

• i valori iniziali mwahqh0-mwahuh7 sono differenti e
• l'output è costruito omettendo mwahch6 e mwahgh7.

Note

cite-note-11. mwah8mwaiamwaieCrittoanalisi dell'SHA-1 (Schneier), su mwaiischneier.com.
cite-note-22. mwaiymwaicmwaigSchneier on Security: NIST Hash Workshop Liveblogging (5), su mwaikschneier.com.
cite-note-33. mwai0mwai4mwai8The H: Security news and Open source developments, su mwajaheise-security.co.uk.
cite-note-autogenerato1-44. mwajymwajcmwajgDocument (mwajkmwajoPDF), su mwajscsrc.nist.gov.
cite-note-55. mwaj8mwakamwakeBounce to index.html, su mwakicsrc.nist.gov mwakm(archiviato dall'mwakqurl originale il 5 febbraio 2008).
cite-note-66. mwakgmwakkmwakoThe Keccak sponge function family, su mwakskeccak.noekeon.org.
cite-note-77. mwak8(mwalamwaleEN) mwalimwalmAnnouncing the first SHA1 collision, su mwalqsecurity.googleblog.com, 23 febbraio 2017. mwaluURL consultato il 17 marzo 2017.
cite-note-88. mwalk(mwalomwalsEN) mwalwmwal0Shattered, su mwal4shattered.it. mwal8URL consultato il 17 marzo 2017. mwame«We have broken SHA-1 in practice.»
cite-note-99. mwamumwamymwamcLicensing Declaration for US patent 6829355.. mwamgURL consultato il 17 febbraio 2008.
cite-note-1010. mwamwHenri Gilbert, Helena Handschuh, mwam0mwam4Security analysis of SHA-256 and sisters, in mwam8Lecture notes in computer science, Springer, Berlin, mwanaISSNmwane 0302-9743. mwankURL consultato il 30 gennaio 2008 mwano(archiviato dall'mwansurl originale il 18 ottobre 2011).
cite-note-111. mwaoamwaoemwaoiWeblog for dkg - HOWTO prep for migration off of SHA-1 in OpenPGP, su mwaomdebian-administration.org. mwaoqURL consultato il 4 maggio 2019 mwaou(archiviato dall'mwaoyurl originale il 3 maggio 2019).

Bibliografia

• Florent Chabaud, Antoine Joux: Differential Collisions in SHA-0. CRYPTO 1998. pp56–71
• mwaowEli Biham, Rafi Chen, Near-Collisions of SHA-0, Cryptology ePrint Archive, Report 2004/146, 2004 (appeared on CRYPTO 2004) mwao0
• Joux, Carribault, Lemuet, Jalby: Collision for the full SHA-0 algorithm, CRYPTO 2004 mwao8
• Xiaoyun Wang, Hongbo Yu and Yiqun Lisa Yin, Efficient Collision Search Attacks on SHA-0, CRYPTO 2005 mwapi
• Xiaoyun Wang, Yiqun Lisa Yin and Hongbo Yu, Finding Collisions in the Full SHA-1, CRYPTO 2005 mwapu
• Henri Gilbert, Helena Handschuh: Security Analysis of SHA-256 and Sisters. mwapkSelected Areas in Cryptography 2003: pp175–193
• mwapsProposed Revision of Federal Information Processing Standard (FIPS) 180, Secure Hash Standard, in Federal Register, vol. 59, n. 131, 11 luglio 1994, pp. 35317-35318. URL consultato il 26 aprile 2007.

Voci correlate

• mwaqmSHA-3

Collegamenti esterni

• citereffoldoc(EN) Denis Howe, Secure Hash Algorithm, in Free On-line Dictionary of Computing. Disponibile con licenza mwaqcGFDL

Siti Internet per il calcolo degli hash

• mwaqsHash'em all! — Hashing online di testo e files con svariati algoritmi
• mwaq0Web4Human — Hashing online con algoritmi SHA1, SHA224, SHA256 e SHA512
• mwaq8https://web.archive.org/web/20071216092901/http://www.johnmaguire.us/tools/hashcalc/index.php – Consente l'encoding di stringhe di lunghezza nulla
• mwareSHA-1 Lookup – Database with several millions SHA-1 hashes. Implemented as an online reverse search.
• mwarmSimple hash calculator, su hash.spugesoft.com. URL consultato il 5 maggio 2019 (archiviato dall'url originale il 28 giugno 2012).
• mwaruSHA-1 Text file line per line – Allows to sha1-hash every line of a text file.

Standard: SHA-0, SHA-1, SHA-2, SHA-3...

• mwarkSpecifications for a Secure Hash Standard (SHS) – Draft for proposed SHS standard (SHA-0)
• mwarsSecure Hash Standard (SHS) – Proposed SHS standard (SHA-0)
• mwar0RFC 3174, “US Secure Hash Algorithm 1 (SHA-1)”
• mwar8RFC 4634, “US Secure Hash Algorithms (SHA and HMAC-SHA)”
• mwaseCSRC Cryptographic Toolkit – Official mwasiNIST site for the Secure Hash Standard

• mwasuFIPS 180-2: Secure Hash Standard (SHS) mwasyArchiviato il 12 marzo 2012 in Internet Archive. (mwasgPDF, 236 kB) – Current version of the Secure Hash Standard (SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512), 1 August 2002, amended 25 February 2004
• mwasoNIST secure hashing Pagina relativa agli algoritmi di hashing del NIST

• mwaswNIST Cryptographic Hash Project SHA-3 competition

Crittoanalisi

• mwataIntervista con Yiqun Lisa Yin sull'attacco all'SHA-1, su news.zdnet.com. URL consultato il 30 gennaio 2008 (archiviato dall'url originale il 16 dicembre 2007).
• mwatiLenstra's Summary of impact of the February 2005 cryptanalytic results (PDF), su cm.bell-labs.com. URL consultato il 30 gennaio 2008 (archiviato dall'url originale il 28 febbraio 2008).
• mwatqExplanation of the successful attacks on SHA-1 (3 pages, 2006)

Implementazioni

• mwatgThe OpenSSL Project – La diffusa libreria mwatkOpenSSL include mwatosoftware libero ed mwatsopen source con implementazione dell'SHA-1, SHA-224, SHA-256, SHA-384 ed SHA-512
• mwat0Crypto++ Crypto++, libreria libera in C++ con schemi crittografici
• mwat8Bouncy Castle La libreria Bouncy Castle è una libreria libera in Java e C# che contiene implementazioni dell'SHA-1, SHA-224, SHA-256, SHA-384 ed SHA-512, e di altri algoritmi di hash.

Tutorial e codici d'esempio

• mwaumComparazione della funzione SHA in differenti linguaggi
• mwauuImplementazioni in C e C++ dell'SHA-1, inclusi binari per Win32 e Linux di Paul E. Jones (RFC Co-Author)
• mwaucImplementazione in C dell'SHA di Brian Gladman
• mwaukImplementazione in Visual Basic dell'SHA-1 di John Taylor
• mwausImplementazione in JavaScript dell'SHA-1 di Chris Veness
• mwau0Implementazione in JavaScript delle funzioni di HASH (md4, md5, sha-1, sha-2), su cryptojs.altervista.org.

Vettori di test

The mwavaNESSIE project mwavetest vectors for mwaviSHA-1, mwavmSHA-256, mwavqSHA-384, and mwavuSHA-512.